﻿// -----------------------------------------------------------------------
// <copyright file="Statement.cs" company="none">
// Copyright (c) 2012 M. Alberti, xanatos(at)live.it
// Based on the articles found at 
// http://blogs.msdn.com/b/mitsu/archive/2010/03/02/c-4-expressions-blocks-part-i.aspx, 
// http://blogs.msdn.com/b/mitsu/archive/2010/03/02/c-4-expressions-variables-part-ii.aspx, and
// http://blogs.msdn.com/b/mitsu/archive/2010/03/02/c-4-expressions-loops-goto-label-if-and-even-for-part-iii.aspx.
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
// </copyright>
// -----------------------------------------------------------------------

namespace FluentStatement
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Linq.Expressions;

    /// <summary>
    /// 
    /// </summary>
    public class Statement
    {
        /// <summary>
        /// 
        /// </summary>
        protected Statement()
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="statement"></param>
        public static void Start(Action<Statement> statement)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="statement"></param>
        /// <returns></returns>
        public static TResult Start<TResult>(Func<Statement, TResult> statement)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public Statement Empty()
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="block"></param>
        /// <returns></returns>
        public Statement Do(Action block)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public Statement Return()
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value"></param>
        /// <returns></returns>
        public Statement Return<T>(T value)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="expression"></param>
        /// <param name="arguments"></param>
        /// <returns></returns>
        public Statement Invoke(Expression expression, params object[] arguments)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="expression"></param>
        /// <param name="arguments"></param>
        /// <returns></returns>
        public Statement Invoke<T>(Expression expression, params object[] arguments)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="block"></param>
        /// <returns></returns>
        public Statement Block(Statement block)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="locals"></param>
        /// <param name="block"></param>
        /// <returns></returns>
        public Statement Block<T>(T locals, Func<T, Statement> block)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public Statement Assign<T>(T variable, T value)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="variable"></param>
        /// <returns></returns>
        public Statement PreIncrement<T>(T variable)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="variable"></param>
        /// <returns></returns>
        public Statement PreDecrement<T>(T variable)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="variable"></param>
        /// <returns></returns>
        public Statement PostIncrement<T>(T variable)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="variable"></param>
        /// <returns></returns>
        public Statement PostDecrement<T>(T variable)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public Statement Increase<T>(T variable, T value)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="variable"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public Statement Decrease<T>(T variable, T value)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="block"></param>
        /// <returns></returns>
        public T Value<T>(Statement block)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public T DefaultValue<T>()
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="label"></param>
        /// <returns></returns>
        public Statement Label(string label)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="label"></param>
        /// <returns></returns>
        public Statement Goto(string label)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="condition"></param>
        /// <param name="block"></param>
        /// <returns></returns>
        public Statement While(bool condition, Statement block)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="block"></param>
        /// <param name="condition"></param>
        /// <returns></returns>
        public Statement DoWhile(Statement block, bool condition)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="block"></param>
        /// <param name="condition"></param>
        /// <returns></returns>
        public Statement DoUntil(Statement block, bool condition)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="locals"></param>
        /// <param name="condition"></param>
        /// <param name="adder"></param>
        /// <param name="block"></param>
        /// <returns></returns>
        public Statement For<T>(T locals, Func<T, bool> condition, Func<T, Statement> adder, Func<T, Statement> block)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="enumerable"></param>
        /// <param name="block"></param>
        /// <returns></returns>
        public Statement ForEach<T>(IEnumerable<T> enumerable, Func<T, Statement> block)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="U"></typeparam>
        /// <param name="enumerable"></param>
        /// <param name="block"></param>
        /// <returns></returns>
        public Statement ForEach<T, U>(T enumerable, Func<U, Statement> block)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public Statement Break()
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public Statement Continue()
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="condition"></param>
        /// <param name="block"></param>
        /// <returns></returns>
        public Statement If(bool condition, Statement block)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="condition"></param>
        /// <param name="block"></param>
        /// <param name="elseBlock"></param>
        /// <returns></returns>
        public Statement If(bool condition, Statement block, Statement elseBlock)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="condition"></param>
        /// <param name="block"></param>
        /// <returns></returns>
        public Tuple<bool, Statement> MakeIf(bool condition, Statement block)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="elseBlock"></param>
        /// <param name="ifs"></param>
        /// <returns></returns>
        public Statement If(Statement elseBlock, params Tuple<bool, Statement>[] ifs)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="condition"></param>
        /// <param name="block"></param>
        /// <returns></returns>
        public Tuple<T[], Statement> MakeCase<T>(T condition, Statement block)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="conditions"></param>
        /// <param name="block"></param>
        /// <returns></returns>
        public Tuple<T[], Statement> MakeCase<T>(T[] conditions, Statement block)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value"></param>
        /// <param name="cases"></param>
        /// <returns></returns>
        public Statement Switch<T>(T value, params Tuple<T[], Statement>[] cases)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value"></param>
        /// <param name="default"></param>
        /// <param name="cases"></param>
        /// <returns></returns>
        public Statement Switch<T>(T value, Statement @default, params Tuple<T[], Statement>[] cases)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="block"></param>
        /// <returns></returns>
        public Statement Lock(object obj, Statement block)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="millisecondsTimeout"></param>
        /// <param name="lockTacken"></param>
        /// <returns></returns>
        public Statement TryLock(object obj, int millisecondsTimeout, Func<bool, Statement> lockTacken)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="timeout"></param>
        /// <param name="lockTacken"></param>
        /// <returns></returns>
        public Statement TryLock(object obj, TimeSpan timeout, Func<bool, Statement> lockTacken)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <param name="block"></param>
        /// <returns></returns>
        public Statement Using<T>(T obj, Func<T, Statement> block) where T : IDisposable
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="ex"></param>
        /// <returns></returns>
        public Statement Throw(Exception ex)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public Statement Rethrow()
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="type"></param>
        /// <param name="block"></param>
        /// <returns></returns>
        public Tuple<Type, Func<Exception, Statement>> MakeCatch(Type type, Func<object, Statement> block)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="type"></param>
        /// <param name="block"></param>
        /// <returns></returns>
        public Tuple<Type, Func<Exception, Statement>> MakeCatch<T>(Type type, Func<T, Statement> block) where T : Exception
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="block"></param>
        /// <param name="catchBlocks"></param>
        /// <returns></returns>
        public Statement TryCatch(Statement block, params Tuple<Type, Func<Exception, Statement>>[] catchBlocks)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="block"></param>
        /// <param name="finallyBlock"></param>
        /// <returns></returns>
        public Statement TryFinally(Statement block, Statement finallyBlock)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="block"></param>
        /// <param name="finallyBlock"></param>
        /// <param name="catchBlocks"></param>
        /// <returns></returns>
        public Statement TryCatchFinally(Statement block, Statement finallyBlock, params Tuple<Type, Func<Exception, Statement>>[] catchBlocks)
        {
            throw new NotSupportedException();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override bool Equals(object obj)
        {
            return base.Equals(obj);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override string ToString()
        {
            return base.ToString();
        }
    }
}
